////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afpdafelements.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AFPDAFELEMENTS_H
#define AFPDAFELEMENTS_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "afglobalelements.h"

#define AFPDAFELEMENTS_NAMESPACE_BEGIN namespace afpdafelements {
#define AFPDAFELEMENTS_NAMESPACE_END }

AFPDAFELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDMultiwindowType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDMultiwindowType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable
    ///
    /// Description:   Enables multi-window auto focus
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HClipRatioNormalLight
    ///
    /// Description:   Normalized x coordinate of top-left corner of multi-window ROI under modest to bright light conditions.
    ///                (x,y) = (0,0) means top-left corner of full field of view.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            HClipRatioNormalLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// VClipRatioNormalLight
    ///
    /// Description:   Normalized y coordinate of top-left corner of multi-window ROI under modest to bright light conditions.
    ///                (x,y) = (0,0) means top-left corner of full field of view.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            VClipRatioNormalLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HClipRatioLowLight
    ///
    /// Description:   Normalized x coordinate of top-left corner of multi-window ROI under low light conditions. (x,y) = (0,0)
    ///                means top-left corner of full field of view.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            HClipRatioLowLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// VClipRatioLowLight
    ///
    /// Description:   Normalized y coordinate of top-left corner of multi-window ROI under low light conditions. (x,y) = (0,0)
    ///                means top-left corner of full field of view.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            VClipRatioLowLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HNumWindows
    ///
    /// Description:   Horizontal grid size of multi-window ROI.
    /// Range:         [1,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            HNumWindows;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// VNumWindows
    ///
    /// Description:   Vertical grid size of multi-window ROI.
    /// Range:         [1,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            VNumWindows;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDPercentile
    ///
    /// Description:   Pd_percentile Description: Nth Percentile of the valid windows to select from.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            PDPercentile;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defocusThreshold
    ///
    /// Description:   Windows within this threshold of the best window will be selected for contrast AF to calcuate FV.
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            defocusThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// confidenceThMultiple
    ///
    /// Description:   the confidence threshold for mw grids will be the min-conf * ConfidenceThMultiple.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            confidenceThMultiple;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// multiDepthDetect
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct multiDepthDetectStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// percentile
        ///
        /// Description:   after sorting, will use this percentile to get the detect size for multi-depth detection.
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT percentile;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detectThLow
        ///
        /// Description:   depth difference from multi-depth detection lower than this threshold when in muti-depth mode ,transition
        ///                to not muti-depth condition.
        /// Range:         [0,500]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT detectThLow;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// detectThHigh
        ///
        /// Description:   depth difference from multi-depth detection higher than this threshold when in not multi-depth mode ,
        ///                transition to multi-depth condition.
        /// Range:         [0,500]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT detectThHigh;
    } multiDepthDetect;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lowLightDetect
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct lowLightDetectStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// gainThLow
        ///
        /// Description:   aec gain lower than this threshold when in lowlight mode , transition to normal light MW condition.
        /// Range:         [0,60]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT gainThLow;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// gainThHigh
        ///
        /// Description:   aec gain higher than this threshold when in normal light mode , transition to low light MW condition.
        /// Range:         [0,60]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT gainThHigh;
    } lowLightDetect;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lockToPeripheralDuringSearch
    ///
    /// Description:   flag whether to lock the roi to Peripheral during search on the Peripheral
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type lockToPeripheralDuringSearch;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// activZoomControl
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct activZoomControlStruct
    {

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// enable
        ///
        /// Description:   Multi-window PDAF will only enable if zoom level is less than mw_active_zoom_threshold.If zoom level is
        ///                higher than this threshold, then PDAF will be configured to 1x1 ROI instead to ensure enough pixels
        ///                located inside. This is flag to enable/disable the mechanism. If this is disabled, then all zoom level
        ///                will run multi-window PDAF, which may have hunting effect at high zoom level.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type enable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// zoomThreshold
        ///
        /// Description:   Multi-window PDAF will only enable if zoom level is less than this threshold.If zoom level level higher
        ///                than this threshold, then PDAF will be configured to 1x1 to ensure enough pixels is located inside.
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            zoomThreshold;
    } activZoomControl;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDInternalType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDInternalType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// type
    ///
    /// Description:   PDAF sensor type used
    /// Range:         [1,3]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            type;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// initialPosition
    ///
    /// Description:   Initial lens position when camera turns on
    /// Range:         [0,500]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            initialPosition;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDAFEnableFaceCAFPriority
    ///
    /// Description:   Flag to enable feature where contrast-based auto focus is invoked if face is detected
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type PDAFEnableFaceCAFPriority;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// incDefocusThresholdPreviousError
    ///
    /// Description:   Increase defocus threshold by this parameter in logical lens units if previous iteration of focus
    ///                converge resulted in error
    /// Range:         [0,20]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            incDefocusThresholdPreviousError;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineScanRangeEnhance
    ///
    /// Description:   When enabled this feature decreases the estimated fine scan range by 25%
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            fineScanRangeEnhance;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// softRegionThresholdMultiplier
    ///
    /// Description:   Description: If defocus value is less than defocus threshold and above soft defocus threshold, then scene
    ///                change determines if PDAF focus convergence is to be triggered Constraints: Soft threshold defocus is the
    ///                calculated by defocusThreshold(tuning) multiplied by softRegionThresholdMultiplier. Decreasing this
    ///                number may cause PDAF to be more sensitive to defocus condition that is accompanied by a scene change.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            softRegionThresholdMultiplier;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableSoftConfidenceThreshold
    ///
    /// Description:   Description: Enables feature which allow the minimum confidence level to slightly decrease during focus
    ///                convergence due to increased aliasing Constraints: Enable this feature if PDAF frequently transitions to
    ///                contrast-based AF in the midst of focus convergence. Generally disabled for Type 1 and enabled for Type 2
    ///                and 3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableSoftConfidenceThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// softConfidenceThresholdDelta
    ///
    /// Description:   Description: Represents the decrease in minimum confidence level allowed during focus convergence if
    ///                enableSoftConfidenceThreshold is enabled Constraints: Increasing this number allows PDAF to employ lower
    ///                minimum confidence level during focus converge. Setting this number higher than the minimum confidence
    ///                level causes minimum confidence level requirement to be omitted during focus converge; hence, a care
    ///                needs to be taken in revising this parameter.
    /// Range:         [0,200]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            softConfidenceThresholdDelta;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// softConfidenceFocus_pnt
    ///
    /// Description:   Description: Represents the scaler by which PDAF focus convergence slows down for PD samples whose
    ///                confidence level resides between minimum confidence level and (minimum confidence level -
    ///                softConfidenceThresholdDelta) Constraints: Decreasing this number causes PDAF to perform focus
    ///                convergence more slowly for PD samples whose confidence level lies between minimum confidence level and
    ///                (minimum confidence level - softConfidenceThresholdDelta)
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            softConfidenceFocus_pnt;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableSoftRegionThresholdHigh
    ///
    /// Description:   Description: It is a boolean flag which indicate if softdefocusThresholdHigh will be used as a parameter
    ///                to trigger focus in soft region when soft region threshold hig(enableSoftRegionThresholdHigh) is enabled.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableSoftRegionThresholdHigh;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// softRegionThresholdHighMultiplier
    ///
    /// Description:   Description: Defocus multiplier to make defocus threshold higher. Please refer to
    ///                enableSoftRegionThresholdHigh image.
    /// Range:         [2,6]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            softRegionThresholdHighMultiplier;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// softSceneChangeCount
    ///
    /// Description:   Description: number of scene changed reported by AF continues.
    /// Range:         [1,6]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            softSceneChangeCount;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDPreprocessingType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDPreprocessingType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable
    ///
    /// Description:   Enables selective filtering of PD sample based on confidence level and abs(PD)
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableDoNotUseDefocusSampleByPD
    ///
    /// Description:   Enables rejection of PD stat if abs(PD) exceeds this threshold
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableDoNotUseDefocusSampleByPD;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableIncMinConfidenceThresholdByPD
    ///
    /// Description:   Enables increasing of minimimum confidence level if abs(PD) is above certain threshold
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableIncMinConfidenceThresholdByPD;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDMaxLimitDoNotUseDefocusSample
    ///
    /// Description:   Minimum threshold applied to abs(PD) above which the corresponding defocus sample is not used
    /// Range:         [12,32]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            PDMaxLimitDoNotUseDefocusSample;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDMaxLimitIncMinConfidenceThreshold
    ///
    /// Description:   Maximum threshold applied to abs(PD) above which minimum confidence is scaled up
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            PDMaxLimitIncMinConfidenceThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// incMinConfidenceThresholdByPDScaler
    ///
    /// Description:   Scaler multiplier by which minimum confidence threshold is increased if abs(PD) is above
    ///                PDMaxLimitIncMinConfidenceThreshold
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            incMinConfidenceThresholdByPDScaler;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDStdThreshold
    ///
    /// Description:   Maximum threshold for std(PD) above which corresponding defocus sample is not used
    /// Range:         [0,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            PDStdThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDDefocusHighErrorScCheck
    ///
    /// Description:   If abs(defocus) is above the threshold defined by (PDDefocusHighErrorScCheck * defocus threshold) then
    ///                focus trigger must also be accompanied by scene change
    /// Range:         [2,30]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            PDDefocusHighErrorScCheck;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDAverageDefocusHighErrScCheck
    ///
    /// Description:   If temporally filtered abs(defocus) is above the threshold defined by (PDAverageDefocusHighErrScCheck *
    ///                defocus threshold) focus trigger must also be accompanied by scene change
    /// Range:         [2,30]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            PDAverageDefocusHighErrScCheck;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDLowlightGainThresholdScCheck
    ///
    /// Description:   If abs(defocus) is below the threshold defined by (PDLowlightGainThresholdScCheck * defocus threshold)
    ///                then focus trigger is to be based on scene change
    /// Range:         [2,30]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            PDLowlightGainThresholdScCheck;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDDefocusHighScCheck - Array
    ///
    /// Description:   If abs(defocus) is below the threshold defined by (PDDefocusHighScCheck * defocus threshold) then focus
    ///                trigger is to be based on scene change
    /// Range:         [2,30]
    /// Min Length:    1
    /// Max Length:    4
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           PDDefocusHighScCheckCount;
    UINT32           PDDefocusHighScCheckID;
    INT32*           PDDefocusHighScCheck;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDAverageDefocusHighScCheck - Array
    ///
    /// Description:   If temporally filtered abs(defocus) is below the threshold defined by (PDAverageDefocusHighScCheck *
    ///                defocus threshold) then focus trigger is to be based on scene change
    /// Range:         [2,30]
    /// Min Length:    1
    /// Max Length:    4
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           PDAverageDefocusHighScCheckCount;
    UINT32           PDAverageDefocusHighScCheckID;
    INT32*           PDAverageDefocusHighScCheck;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDLowlightDefocusHighScCheck - Array
    ///
    /// Description:   If abs(defocus) is below the threshold defined by (PDLowlightDefocusHighScCheck * defocus threshold) then
    ///                focus trigger is to be based on scene change
    /// Range:         [2,30]
    /// Min Length:    1
    /// Max Length:    4
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           PDLowlightDefocusHighScCheckCount;
    UINT32           PDLowlightDefocusHighScCheckID;
    INT32*           PDLowlightDefocusHighScCheck;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDLowlightAverageDefocusHighScCheck - Array
    ///
    /// Description:   If temporally filtered abs(defocus) is below the threshold defined by
    ///                (PDLowlightAverageDefocusHighScCheck * defocus threshold) then focus trigger is to be based on scene
    ///                change
    /// Range:         [2,30]
    /// Min Length:    1
    /// Max Length:    4
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           PDLowlightAverageDefocusHighScCheckCount;
    UINT32           PDLowlightAverageDefocusHighScCheckID;
    INT32*           PDLowlightAverageDefocusHighScCheck;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDMonitorType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDMonitorType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// waitAfterFocusCount
    ///
    /// Description:   Number of frames to wait after focus search finishes before detecting out-of-focus (or defocus) condition
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            waitAfterFocusCount;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// waitConfidenceRecoverCount
    ///
    /// Description:   Number of frames to wait for confidence level to recover from a temporary drop (e.g. scene change)
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            waitConfidenceRecoverCount;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defocusedThreshold
    ///
    /// Description:   Minimum size of absolute defocus below which lens is assumed to be in focus
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            defocusedThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// depthStableThreshold
    ///
    /// Description:   Maximum size of frame-to-frame difference in temporally filtered defocus above which defocus is deemed
    ///                not stable. Focus convergence can only be triggered if defocus is deemed stable
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            depthStableThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defocusStableFilterLength
    ///
    /// Description:   Size of moving average filter applied to defocus sample
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            defocusStableFilterLength;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableTriggerSuppressionBySceneChange
    ///
    /// Description:   If enabled, focus trigger is suppressed until scene change is also detected
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableTriggerSuppressionBySceneChange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defocusDOFMultiplier
    ///
    /// Description:   Maximum scaler by which the dept of focus is deemed to increase from hyperfocal distance to 10-cm
    /// Range:         [0,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            defocusDOFMultiplier;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defocusThresholdScaler
    ///
    /// Description:   Scaler by which defocus threshold is multiplied if scene change is not detected
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            defocusThresholdScaler;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDFocusScanType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDFocusScanType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// focusConvergeFrameSkip
    ///
    /// Description:   Number of frame skip to use during PDAF focus convergence
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            focusConvergeFrameSkip;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableFineScan
    ///
    /// Description:   Enable contrast-based fine scan following PDAF focus convergence
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableFineScan;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minimumFineScanRange
    ///
    /// Description:   Minimum fine scan range expressed as scaler multiple to computed fine scan step size.
    /// Range:         [1,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            minimumFineScanRange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineScanStepSize
    ///
    /// Description:   Minimum fine scan step size to use for contrast-based fine scan following PDAF focus converge
    /// Range:         [1,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            fineScanStepSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// focusDoneThreshold
    ///
    /// Description:   Minimum absolute defocus value below which focus converge is deemed to be done
    /// Range:         [0,50]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            focusDoneThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableFineScanExtension
    ///
    /// Description:   Enables contrast-based fine scan following PDAF focus convergence to extend search limit as needed to
    ///                find focus peak
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableFineScanExtension;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// firstRunNotConfidenceAdd
    ///
    /// Description:   Increases frame count by which PDAF waits for valid defocus statistics to arrive for the first camera
    ///                turn on
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            firstRunNotConfidenceAdd;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDDofScalerEntryType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDDofScalerEntryType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// normalizedLensPosition
    ///
    /// Description:   Normalized lens position, if lens position is near end, the value is 1, if lens position is far end, the
    ///                value is 0.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT normalizedLensPosition;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dofScaler
    ///
    /// Description:   DOF scaler value at the given normalized lens position, this scaler will be applied to fine scan step
    ///                size, defocus threshold, focus done threshold etc./
    /// Range:         [1,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT dofScaler;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDDofScalerTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDDofScalerTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dofScalerEntries - Array
    /// Min Length:    1
    /// Max Length:    20
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                         dofScalerEntriesCount;
    UINT32                         dofScalerEntriesID;
    chromatixPDDofScalerEntryType* dofScalerEntries;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDStableTableEntryType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDStableTableEntryType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FPS
    ///
    /// Description:   Frame rate per second
    /// Range:         [0,120]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 FPS;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minimumStableCount
    ///
    /// Description:   Number of frames in which defocus values must remain stable in order for PDAF algorithm to trigger focus
    ///                convergence
    /// Range:         [0,30]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 minimumStableCount;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDStableTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDStableTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stableEntries - Array
    /// Min Length:    1
    /// Max Length:    20
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                           stableEntriesCount;
    UINT32                           stableEntriesID;
    chromatixPDStableTableEntryType* stableEntries;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDConfidenceTableEntryType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDConfidenceTableEntryType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseGain
    ///
    /// Description:   Noise level in dB computed as as 20.0 * log10(sensor_gain)
    /// Range:         [0,40]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT noiseGain;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minimumConfidence
    ///
    /// Description:   Minimum confidence level at the given noise level in dB. Defocus valuese whose confidence level is below
    ///                the minimum threshold is deemed not confident
    /// Range:         [0,1023]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 minimumConfidence;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDConfidenceTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDConfidenceTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// confidenceEntries - Array
    /// Min Length:    1
    /// Max Length:    20
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                               confidenceEntriesCount;
    UINT32                               confidenceEntriesID;
    chromatixPDConfidenceTableEntryType* confidenceEntries;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDNoiseTableEntryType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDNoiseTableEntryType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseGain
    ///
    /// Description:   Noise level in dB computed as as 20.0 * log10(sensor_gain)
    /// Range:         [0,40]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT noiseGain;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseGainMultiplier
    ///
    /// Description:   Scaler by which size of rms noise increases. Scaler value of 1 implies rms noise is identical to the case
    ///                where sensor gain is 1X
    /// Range:         [1,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT noiseGainMultiplier;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDNoiseTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDNoiseTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseEntries - Array
    /// Min Length:    1
    /// Max Length:    20
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          noiseEntriesCount;
    UINT32                          noiseEntriesID;
    chromatixPDNoiseTableEntryType* noiseEntries;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDFocusTableEntryType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDFocusTableEntryType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defocus
    ///
    /// Description:   Defocus in logical lens position unit
    /// Range:         [0,500]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 defocus;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// movePercent
    ///
    /// Description:   Percentage lens movement to target lens position
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT movePercent;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDFocusTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDFocusTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// focusEntries - Array
    /// Min Length:    1
    /// Max Length:    20
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          focusEntriesCount;
    UINT32                          focusEntriesID;
    chromatixPDFocusTableEntryType* focusEntries;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDROIConfigType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDROIConfigType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROILocationY
    ///
    /// Description:   Y-coordinate for top-left corner of ROI in grid-based stats
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 ROILocationY;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROILocationX
    ///
    /// Description:   X-coordinate for top-left corner of ROI in grid-based stats
    /// Range:         [0,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 ROILocationX;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROINumRows
    ///
    /// Description:   Height of ROI in number of rows in grid-based stats
    /// Range:         [1,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 ROINumRows;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROINumCols
    ///
    /// Description:   Width of ROI in number of columns in grid-based stats
    /// Range:         [1,5]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 ROINumCols;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDROIType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDROIType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Configuration - Array
    /// Min Length:    1
    /// Max Length:    10
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                    ConfigurationCount;
    UINT32                    ConfigurationID;
    chromatixPDROIConfigType* Configuration;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDAFType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// parameter_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct parameter_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } parameter_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// is2PDEnable
    ///
    /// Description:   Enable PDAF specific to dual-photodiode type image sensor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL                           is2PDEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ROI
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDROIType             ROI;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// focusTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDFocusTableType      focusTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDNoiseTableType      noiseTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// confidenceTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDConfidenceTableType confidenceTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// confidenceHighTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDConfidenceTableType confidenceHighTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fallbackConfidence
    ///
    /// Description:   Threshold applied to PD confidence level to decide when to perform fallback to other AF algorithm.
    /// Range:         [0,1023]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                         fallbackConfidence;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stableTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDStableTableType     stableTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dofScalerTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDDofScalerTableType  dofScalerTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// focusScan
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDFocusScanType       focusScan;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sceneMonitor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDMonitorType         sceneMonitor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDPreprocessing
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDPreprocessingType   PDPreprocessing;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDInternal
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDInternalType        PDInternal;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDMultiWindow
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDMultiwindowType     PDMultiWindow;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableCheckVHStatsRatio
    ///
    /// Description:   Sony confirms that type 1 lib will generate inaccurate PD value with high confidence in scene of 5-30
    ///                degree stripe line. We use this flag to enable a function which will detect this scene by ratio of H, V
    ///                focus value and set PDAF 'isConfidence' false when this scene is detected.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type               enableCheckVHStatsRatio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// VHStatsRatioUnconfidentThreshold
    ///
    /// Description:   Sony confirms that type 1 lib will generate inaccurate PD value with high confidence in scene of 5-30
    ///                degree stripe line. We set PD 'isConfidence' false if ratio H, V focus value is larger than this
    ///                threshold.
    /// Range:         [0,20]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                          VHStatsRatioUnconfidentThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enablePDEarlyInterrupt
    ///
    /// Description:   If early interrupt is supported and PDLib is handled in sensor side, this flag should be true, otherwise
    ///                stays false. Important dependency, please pay attention. PD_early_interrupt_enabled = 1 then
    ///                focus_conv_frame_skip = 0 PD_early_interrupt_enabled = 0 then focus_conv_frame_skip = 1 For PD early
    ///                interrupt to work, BAF ROI should be the same as PDAF ROI. PDAF ROI will be set in imx362_pdaf.h. Look
    ///                for (pdaf_address_end_hori, etc) In tuning header h_clip_ratio_normal_light = pdaf_address_end_hori -
    ///                pdaf_address_start_hori. The same for vertical.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type               enablePDEarlyInterrupt;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ledPdafMaxFrameAllow
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct ledPdafMaxFrameAllowStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// enable
        ///
        /// Description:   LED PDAF convergence max frame control enable flag. When this flag is enabled, it will read
        ///                LED_PDAF_max_frame_cnt and force LED PDAF to complete converge when converge frame is more than the max
        ///                allowed. This prevents power drain and app timeout in case of constantscene panning.
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type enable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// maxFrameCnt
        ///
        /// Description:   PDAF stats is forced to enter focus converge done when LED pd converge is over this threshold
        /// Range:         [1,200]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32           maxFrameCnt;
    } ledPdafMaxFrameAllow;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sparsePDTouchFaceConfidenceThreshold
    ///
    /// Description:   Confidence threshold required to determine if to fallback or run PDAF while touch/face.
    /// Range:         [0,1023]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                          sparsePDTouchFaceConfidenceThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sparsePDTouchFaceLowDefocusConfidenceThreshold
    ///
    /// Description:   Confidence threshold required to determine if to fallback or fine scan while touch/face.
    /// Range:         [0,1023]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                          sparsePDTouchFaceLowDefocusConfidenceThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableEnterLSPLowConfidenceHunting
    ///
    /// Description:   PD variation is large in some test scene and cause hunting issue. Force this test scene enter to LSP when
    ///                sign of PD is reverted in some times. LSP will use contrast information to find final position.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type               enableEnterLSPLowConfidenceHunting;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LSPLowConfidenceHuntingThreshold
    ///
    /// Description:   PDAF stats is forced to enter focus converge done when sign of PD reverted counter is over this
    ///                threshold.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                          LSPLowConfidenceHuntingThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// face
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct faceStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// minMoveThreshold
        ///
        /// Description:   While running face tracking for 2PD, if defocus is less than this threshold then focus search will not be
        ///                re-triggered
        /// Range:         [0,7]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32                   minMoveThreshold;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ROIMoveConvergeSuppress
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct ROIMoveConvergeSuppressStruct
        {
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// Binary file symbol table entry ID
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 SymbolTableID;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable
            ///
            /// Description:   Enable flag for face 2pd ROI move converge suppress
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            BOOL   enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// stableCountThreshold
            ///
            /// Description:   Stable counter threshold for face 2PD roi move converge suppress.Once face ROI is less than moving
            ///                threshold for continuous frames over the counter PDAF will resume converging
            /// Range:         [1,100]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 stableCountThreshold;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// moveThresholdInX
            ///
            /// Description:   Face tracking 2PD, if ROI is moving over defined X threshold, then converge suppress will occur
            /// Range:         [0.1,1.0]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            FLOAT  moveThresholdInX;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// moveThresholdInY
            ///
            /// Description:   Face tracking 2PD, if ROI is moving over defined Y threshold, then converge suppress will occur
            /// Range:         [0.1,1.0]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            FLOAT  moveThresholdInY;
        } ROIMoveConvergeSuppress;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// defocusFilter
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct defocusFilterStruct
        {
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// Binary file symbol table entry ID
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 SymbolTableID;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable
            ///
            /// Description:   Face tracking 2PD, temporal filter to calculate average target position and use target positon to
            ///                calculate average defocus and next position
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            BOOL   enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// length
            ///
            /// Description:   Face tracking 2PD, length of moving average filter applied to target lens position
            /// Range:         [1,10]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 length;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// confidenceHighThreshold
            ///
            /// Description:   Face tracking 2PD, if confidence is above this threshold then lens is moved to 100% of defocus. If
            ///                confidence is lower than min_conf the lens is not moved. If confidence is between this threshold and
            ///                min_conf then the lens is moved by interpolated percentage
            /// Range:         [0,1023]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 confidenceHighThreshold;
        } defocusFilter;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// fallback
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct fallbackStruct
        {
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// Binary file symbol table entry ID
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 SymbolTableID;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable
            ///
            /// Description:   Face tracking 2PD is always in converge state. This flag is used to enable fallback in some specification
            ///                condition. If face fallback condition is met and this flag is enable then fallback to contrast-based AF
            ///                is invoked
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            BOOL   enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// fallbackROISizeThreshold
            ///
            /// Description:   Face tracking 2PD, enter fallback status if one of ROI dimension is small than this threshold
            /// Range:         [0,4032]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 fallbackROISizeThreshold;
        } fallback;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// faceChangeRefocusTrigger
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        struct faceChangeRefocusTriggerStruct
        {
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// Binary file symbol table entry ID
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 SymbolTableID;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// enable
            ///
            /// Description:   Enable face PDAF face change refocus trigger. When face change criteria is satisfied then scene change
            ///                flag will be raised and PDAF refocus will be triggered.
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            BOOL   enable;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// roiChangeThreshPercentage
            ///
            /// Description:   When face ROI vs. reference ROI has moved more than thresh percentage, face refocus will trigger.
            ///                Percentage is calculated by face ROI move delta divide by CAMIF width or height.
            /// Range:         [0,1]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            FLOAT  roiChangeThreshPercentage;

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /// roiSizeStableThresh
            ///
            /// Description:   When current face ROI vs. last frame face ROI moves less than this pixel threshold, we report face
            ///                regains stability. This is not a percentage.
            /// Range:         [0,100]
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            UINT32 roiSizeStableThresh;
        } faceChangeRefocusTrigger;
    } face;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// touch
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct touchStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// offCenterThreshold
        ///
        /// Description:   Radius distance from touch ROI to center ROI in terms of dist divided by CAMIF radius. This value is a
        ///                percentage of camif radius. Image center PD perforamnce is better than corner. When defocus is large
        ///                enough, corner image PD may not accurate enough and hit over-shoot situation. This threshold to divide
        ///                FOV to two zone: center/corner. If corner zone defocus is large lens is moved incrementally
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        FLOAT            offCenterThreshold;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// skipSearchIfSceneInFocus
        ///
        /// Description:   flag to enable PDAF skip refocus if scene is already in focus.
        /// Range:         [0,1]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        afglobalelements::enable_flag_type skipSearchIfSceneInFocus;
    } touch;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// convergeDoneFilter
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct convergeDoneFilterStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// enable
        ///
        /// Description:   Flag to enable temproal filter applied to target lens position during focus converge
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        BOOL   enable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// length
        ///
        /// Description:   Length of moving average filter applied to target lens position during focus converge
        /// Range:         [1,5]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 length;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// threshold
        ///
        /// Description:   Threshold used to assess focus done condition. If the difference between target lens position and the
        ///                next lens position is less then this threshold then focus convergence is done
        /// Range:         [1,900]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 threshold;
    } convergeDoneFilter;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// forceEnterFineSearch
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct forceEnterFineSearchStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// enable
        ///
        /// Description:   Force enabling or disabling of contrast-based fine scan
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        BOOL   enable;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// directionReverseCountThreshold
        ///
        /// Description:   TODO_DESCRIPTION
        /// Range:         [0,10]
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 directionReverseCountThreshold;
    } forceEnterFineSearch;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDAFTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class chromatixPDAFTypeClass : public ParameterModule, public chromatixPDAFType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 3;
    static const UINT16 MINOR = 4;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDAFTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDAFTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatixPDAFTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDMultiwindowType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDMultiwindowType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDMultiwindowType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDMultiwindowType_multiDepthDetectStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDMultiwindowType_multiDepthDetectStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDMultiwindowType::multiDepthDetectStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDMultiwindowType_lowLightDetectStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDMultiwindowType_lowLightDetectStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDMultiwindowType::lowLightDetectStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDMultiwindowType_activZoomControlStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDMultiwindowType_activZoomControlStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDMultiwindowType::activZoomControlStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDInternalType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDInternalType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDInternalType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDPreprocessingType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDPreprocessingType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDPreprocessingType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDMonitorType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDMonitorType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDMonitorType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDFocusScanType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDFocusScanType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDFocusScanType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDDofScalerEntryType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDDofScalerEntryType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDDofScalerEntryType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDDofScalerTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDDofScalerTableType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDDofScalerTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDStableTableEntryType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDStableTableEntryType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDStableTableEntryType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDStableTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDStableTableType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDStableTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDConfidenceTableEntryType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDConfidenceTableEntryType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDConfidenceTableEntryType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDConfidenceTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDConfidenceTableType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDConfidenceTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDNoiseTableEntryType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDNoiseTableEntryType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDNoiseTableEntryType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDNoiseTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDNoiseTableType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDNoiseTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDFocusTableEntryType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDFocusTableEntryType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDFocusTableEntryType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDFocusTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDFocusTableType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDFocusTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDROIConfigType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDROIConfigType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDROIConfigType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDROIType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDROIType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDROIType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDAFType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDAFType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load parameter_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadparameter_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::parameter_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ledPdafMaxFrameAllowStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadledPdafMaxFrameAllowStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::ledPdafMaxFrameAllowStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load faceStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadfaceStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::faceStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load faceStruct_ROIMoveConvergeSuppressStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadfaceStruct_ROIMoveConvergeSuppressStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::faceStruct::ROIMoveConvergeSuppressStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load faceStruct_defocusFilterStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadfaceStruct_defocusFilterStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::faceStruct::defocusFilterStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load faceStruct_fallbackStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadfaceStruct_fallbackStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::faceStruct::fallbackStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load faceStruct_faceChangeRefocusTriggerStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadfaceStruct_faceChangeRefocusTriggerStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::faceStruct::faceChangeRefocusTriggerStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load touchStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadtouchStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::touchStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load convergeDoneFilterStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadconvergeDoneFilterStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::convergeDoneFilterStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load forceEnterFineSearchStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadforceEnterFineSearchStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDAFType::forceEnterFineSearchStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixPDPreprocessingType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixPDPreprocessingType(
        chromatixPDPreprocessingType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixPDDofScalerTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixPDDofScalerTableType(
        chromatixPDDofScalerTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixPDStableTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixPDStableTableType(
        chromatixPDStableTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixPDConfidenceTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixPDConfidenceTableType(
        chromatixPDConfidenceTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixPDNoiseTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixPDNoiseTableType(
        chromatixPDNoiseTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixPDFocusTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixPDFocusTableType(
        chromatixPDFocusTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixPDROIType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixPDROIType(
        chromatixPDROIType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixPDAFType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixPDAFType(
        chromatixPDAFType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class chromatixPDAFTypeClass

AFPDAFELEMENTS_NAMESPACE_END
#endif // AFPDAFELEMENTS_H

